BaseAuthService - Code Metrics - Inspection of "Removed dependency on ngx-cacheable, refactoring,..." - cothema/ionic-universal-firebase-login - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 67261f...67f253 )

by Miloš

created 2020-02-04 23:27 UTC

BaseAuthService A

↳ Parent: src/services/base-auth-service.ts

Complexity

Total Complexity

Size/Duplication

Total Lines	214
Duplicated Lines	0 %

Importance

Changes

Metric	Value
wmc	22
eloc	171
dl	0
loc	214
rs	10
c	0
b	0
f	0

13 Functions

Rating	Name	Size	Complexity
A	redirectAfterLogin	5	2
A	signInAnonymously	11	1
A	signOut	15	3
A	signInViaEmail	11	1
A	signInByProvider	21	3
A	redirectAfterSignOut	4	2
A	signInViaTwitter	11	1
A	subscribeUserChanges	19	4
A	updateUserData	5	1
A	signInViaGoogle	11	1
A	signInViaGithub	11	1
A	signInViaFacebook	11	1
A	signInViaPhone	11	1

import { Injectable } from "@angular/core";
import { AngularFireAuth } from "@angular/fire/auth";
import { Router } from "@angular/router";
import { Platform } from "@ionic/angular";
import { auth as firebaseAuth, User as FirebaseUser } from "firebase";
import { auth } from "firebase/app";
import { BehaviorSubject, Observable, Subscription } from "rxjs";
import { UniFirebaseLoginConfig } from "../config/uni-firebase-login-config";
import { UniFirebaseLoginConfigProvider } from "../config/uni-firebase-login-config-provider";
import { UserModel } from "../model/user-model";
import { AuthProvider } from "../providers/auth-provider";
import { IAuthProvider } from "../providers/i-auth-provider";
import { AuthStorageProvider } from "../storage/auth-storage-provider.service";
import { IAuthService } from "./i-auth-service";

@Injectable({
    providedIn: "root",
})
export class BaseAuthService<User extends UserModel = UserModel>
    implements IAuthService {
    public get user(): User | null {
        return this._user.getValue();
    }

    public get user$(): Observable<User | null> {
        return this._user;
    }

    public get userInitialized(): boolean {
        return this._userInitialized.getValue();
    }

    public get userInitialized$(): Observable<boolean> {
        return this._userInitialized;
    }

    public get currentFirebaseUser(): FirebaseUser | null {
        return firebaseAuth().currentUser;
    }

    protected config: UniFirebaseLoginConfig;
    protected _user: BehaviorSubject<User | null> = new BehaviorSubject<User | null>(
        null,
    );
    protected _userInitialized: BehaviorSubject<boolean> = new BehaviorSubject<
        boolean
    >(false);
    private userDataSubscription: Subscription | undefined;

    public constructor(
        protected router: Router,
        protected platform: Platform,
        protected authProvider: AuthProvider,
        protected authStorageProvider: AuthStorageProvider<User>,
        protected angularFireAuth: AngularFireAuth,
        configProvider: UniFirebaseLoginConfigProvider,
    ) {
        this.config = configProvider.config;
        this.subscribeUserChanges();
    }

    public async signInByProvider(
        provider: IAuthProvider,
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        const credential = await provider.handleLogin();
        if (
            this.config.storage !== false &&
            credential &&
            credential.user !== null
        ) {
            await this.authStorageProvider
                .getProvider()
                .updateStoredDataByFirebaseUser(credential.user);
        }
        await callbackBeforeRedirect(credential);
        if (redirect) {
            await this.redirectAfterLogin();
        }
    }

    public async signInAnonymously(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authAnonymous,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaEmail(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authEmail,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaFacebook(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authFacebook,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaGithub(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authGithub,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaGoogle(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authGoogle,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaPhone(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authPhone,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaTwitter(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authTwitter,
            redirect,
            callbackBeforeRedirect,
        );
    }

    /**
     * Handle sign out request
     */
    public async signOut(): Promise<void> {
        const currentUser = auth().currentUser;

        if (currentUser) {
            const providers = this.authProvider.getProvidersByUser(currentUser);

            for (const provider of providers) {
                await provider.handleSignOut();
            }
        }
        await this.redirectAfterSignOut();
    }

    public async updateUserData(user: User) {
        await this.authStorageProvider
            .getProvider()
            .updateStoredDataByUser(user);
    }

    protected async redirectAfterSignOut() {
        if (this.config.signInPage) {
            await this.router.navigate([this.config.signInPage]);
        }
    }

    protected async redirectAfterLogin() {
        if (this.config.afterSignInPage) {
            console.log("Redirect ", this.config.afterSignInPage);
            await this.router.navigate([this.config.afterSignInPage]);
        }
    }

    private subscribeUserChanges(): void {
        this.angularFireAuth.authState.subscribe((user: any) => {
            if (user) {
                if (this.userDataSubscription) {
                    this.userDataSubscription.unsubscribe();
                }
                this.userDataSubscription = this.authStorageProvider
                    .getProvider()
                    .subscribeUserDataFromStorageByFirebaseUser(user)
                    .subscribe(result => {
                        this._user.next(result);
                    });
            } else {
                // Logged out
                this._user.next(null);
            }
            if (!this._userInitialized.getValue()) {
                this._userInitialized.next(true);
            }
        });
    }
}


1			import { Injectable } from "@angular/core";
2			import { AngularFireAuth } from "@angular/fire/auth";
3			import { Router } from "@angular/router";
4			import { Platform } from "@ionic/angular";
5			import { auth as firebaseAuth, User as FirebaseUser } from "firebase";
6			import { auth } from "firebase/app";
7			import { BehaviorSubject, Observable, Subscription } from "rxjs";
8			import { UniFirebaseLoginConfig } from "../config/uni-firebase-login-config";
9			import { UniFirebaseLoginConfigProvider } from "../config/uni-firebase-login-config-provider";
10			import { UserModel } from "../model/user-model";
11			import { AuthProvider } from "../providers/auth-provider";
12			import { IAuthProvider } from "../providers/i-auth-provider";
13			import { AuthStorageProvider } from "../storage/auth-storage-provider.service";
14			import { IAuthService } from "./i-auth-service";
15
16			@Injectable({
17			providedIn: "root",
18			})
19			export class BaseAuthService<User extends UserModel = UserModel>
20			implements IAuthService {
21			public get user(): User \| null {
22			return this._user.getValue();
23			}
24
25			public get user$(): Observable<User \| null> {
26			return this._user;
27			}
28
29			public get userInitialized(): boolean {
30			return this._userInitialized.getValue();
31			}
32
33			public get userInitialized$(): Observable<boolean> {
34			return this._userInitialized;
35			}
36
37			public get currentFirebaseUser(): FirebaseUser \| null {
38			return firebaseAuth().currentUser;
39			}
40
41			protected config: UniFirebaseLoginConfig;
42			protected _user: BehaviorSubject<User \| null> = new BehaviorSubject<User \| null>(
43			null,
44			);
45			protected _userInitialized: BehaviorSubject<boolean> = new BehaviorSubject<
46			boolean
47			>(false);
48			private userDataSubscription: Subscription \| undefined;
49
50			public constructor(
51			protected router: Router,
52			protected platform: Platform,
53			protected authProvider: AuthProvider,
54			protected authStorageProvider: AuthStorageProvider<User>,
55			protected angularFireAuth: AngularFireAuth,
56			configProvider: UniFirebaseLoginConfigProvider,
57			) {
58			this.config = configProvider.config;
59			this.subscribeUserChanges();
60			}
61
62			public async signInByProvider(
63			provider: IAuthProvider,
64			redirect: boolean = true,
65			callbackBeforeRedirect: (
66			credential: auth.UserCredential \| null,
67			) => Promise<void> \| void = () => undefined,
68			): Promise<void> {
69			const credential = await provider.handleLogin();
70			if (
71			this.config.storage !== false &&
72			credential &&
73			credential.user !== null
74			) {
75			await this.authStorageProvider
76			.getProvider()
77			.updateStoredDataByFirebaseUser(credential.user);
78			}
79			await callbackBeforeRedirect(credential);
80			if (redirect) {
81			await this.redirectAfterLogin();
82			}
83			}
84
85			public async signInAnonymously(
86			redirect: boolean = true,
87			callbackBeforeRedirect: (
88			credential: auth.UserCredential \| null,
89			) => Promise<void> \| void = () => undefined,
90			): Promise<void> {
91			await this.signInByProvider(
92			this.authProvider.authAnonymous,
93			redirect,
94			callbackBeforeRedirect,
95			);
96			}
97
98			public async signInViaEmail(
99			redirect: boolean = true,
100			callbackBeforeRedirect: (
101			credential: auth.UserCredential \| null,
102			) => Promise<void> \| void = () => undefined,
103			): Promise<void> {
104			await this.signInByProvider(
105			this.authProvider.authEmail,
106			redirect,
107			callbackBeforeRedirect,
108			);
109			}
110
111			public async signInViaFacebook(
112			redirect: boolean = true,
113			callbackBeforeRedirect: (
114			credential: auth.UserCredential \| null,
115			) => Promise<void> \| void = () => undefined,
116			): Promise<void> {
117			await this.signInByProvider(
118			this.authProvider.authFacebook,
119			redirect,
120			callbackBeforeRedirect,
121			);
122			}
123
124			public async signInViaGithub(
125			redirect: boolean = true,
126			callbackBeforeRedirect: (
127			credential: auth.UserCredential \| null,
128			) => Promise<void> \| void = () => undefined,
129			): Promise<void> {
130			await this.signInByProvider(
131			this.authProvider.authGithub,
132			redirect,
133			callbackBeforeRedirect,
134			);
135			}
136
137			public async signInViaGoogle(
138			redirect: boolean = true,
139			callbackBeforeRedirect: (
140			credential: auth.UserCredential \| null,
141			) => Promise<void> \| void = () => undefined,
142			): Promise<void> {
143			await this.signInByProvider(
144			this.authProvider.authGoogle,
145			redirect,
146			callbackBeforeRedirect,
147			);
148			}
149
150			public async signInViaPhone(
151			redirect: boolean = true,
152			callbackBeforeRedirect: (
153			credential: auth.UserCredential \| null,
154			) => Promise<void> \| void = () => undefined,
155			): Promise<void> {
156			await this.signInByProvider(
157			this.authProvider.authPhone,
158			redirect,
159			callbackBeforeRedirect,
160			);
161			}
162
163			public async signInViaTwitter(
164			redirect: boolean = true,
165			callbackBeforeRedirect: (
166			credential: auth.UserCredential \| null,
167			) => Promise<void> \| void = () => undefined,
168			): Promise<void> {
169			await this.signInByProvider(
170			this.authProvider.authTwitter,
171			redirect,
172			callbackBeforeRedirect,
173			);
174			}
175
176			/**
177			* Handle sign out request
178			*/
179			public async signOut(): Promise<void> {
180			const currentUser = auth().currentUser;
181
182			if (currentUser) {
183			const providers = this.authProvider.getProvidersByUser(currentUser);
184
185			for (const provider of providers) {
186			await provider.handleSignOut();
187			}
188			}
189			await this.redirectAfterSignOut();
190			}
191
192			public async updateUserData(user: User) {
193			await this.authStorageProvider
194			.getProvider()
195			.updateStoredDataByUser(user);
196			}
197
198			protected async redirectAfterSignOut() {
199			if (this.config.signInPage) {
200			await this.router.navigate([this.config.signInPage]);
201			}
202			}
203
204			protected async redirectAfterLogin() {
205			if (this.config.afterSignInPage) {
206			console.log("Redirect ", this.config.afterSignInPage);
207			await this.router.navigate([this.config.afterSignInPage]);
208			}
209			}
210
211			private subscribeUserChanges(): void {
212			this.angularFireAuth.authState.subscribe((user: any) => {
213			if (user) {
214			if (this.userDataSubscription) {
215			this.userDataSubscription.unsubscribe();
216			}
217			this.userDataSubscription = this.authStorageProvider
218			.getProvider()
219			.subscribeUserDataFromStorageByFirebaseUser(user)
220			.subscribe(result => {
221			this._user.next(result);
222			});
223			} else {
224			// Logged out
225			this._user.next(null);
226			}
227			if (!this._userInitialized.getValue()) {
228			this._userInitialized.next(true);
229			}
230			});
231			}
232			}
233

cothema / ionic-universal-firebase-login

Push — master ( 67261f...67f253 )

BaseAuthService A

Complexity

Size/Duplication

Importance

13 Functions

Duplication Side-by-Side

Filter issues like